home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / pxtable.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-10  |  7.8 KB  |  334 lines
  1. #include "pxtable.h"
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5.  
  6. KH_PXTable::KH_PXTable(char* fName, int idx,
  7.                int fNo, char** fields, char** types)
  8.     {
  9.     int exist;                              // Open or create new ?
  10.     pxErr = PXTblExist(fName, &exist);
  11.     if(pxErr != PXSUCCESS)                  // Invalid file name
  12.     return;                             //     Constructor fails
  13.     if(exist)                               // If table already exists
  14.     {                                   //     Is it possible to open
  15.     if((pxErr = PXTblOpen(fName, &tblHandle, idx, 0)) != PXSUCCESS)
  16.         exit(1);
  17.     }
  18.     else
  19.     {                                   // No such table - create new
  20.     if((pxErr = PXTblCreate(fName, fNo, fields, types)) != PXSUCCESS)
  21.         exit(1);                         // And open it
  22.     if((pxErr = PXTblOpen(fName, &tblHandle, 0, 0)) != PXSUCCESS)
  23.         exit(1);
  24.     }
  25.     if((pxErr = PXRecBufOpen(tblHandle, &recHandle)) != PXSUCCESS)
  26.     {
  27.     exit(1);
  28.         }
  29.     current = 1;                            // Current is the 1-st record
  30.     pxErr = PXTblNRecs(tblHandle, &nRecords);       // Determine total table size
  31.     pxErr = PXRecNFlds(tblHandle, &nFlds);          // Number of fields in record
  32.  
  33.     pxErr = PXRecFirst(tblHandle);          // Dummy reposition
  34.     fileName = strdup(fName);
  35.     KH_SHARE = 1;                           // SHARE not used in ver. 1.0
  36.     }
  37. ///////////////////////////////////
  38. KH_PXTable::~KH_PXTable()
  39.     {
  40.     delete fileName;
  41.     pxErr = PXTblClose(tblHandle);
  42.     }
  43. ///////////////////////////////////
  44. int KH_PXTable::set_file(char* fName)
  45.     {
  46.     int exist;                              // Open or create new ?
  47.     pxErr = PXTblExist(fName, &exist);
  48.     if(pxErr != PXSUCCESS)                  // Invalid file name
  49.     exit(1);
  50.     if(!exist)
  51.     return 0;
  52.  
  53.     delete fileName;
  54.     pxErr = PXTblClose(tblHandle);
  55.  
  56.     if((pxErr = PXTblOpen(fName, &tblHandle, 0, 0)) != PXSUCCESS)
  57.     exit(1);
  58.     if((pxErr = PXRecBufOpen(tblHandle, &recHandle)) != PXSUCCESS)
  59.     {
  60.     exit(1);
  61.         }
  62.     current = 1;                            // Current is the 1-st record
  63.     pxErr = PXRecFirst(tblHandle);          // Dummy reposition
  64.     fileName = strdup(fName);
  65.     return 1;
  66.     }
  67. ///////////////////////////////////
  68. KH_FIELD_TYPE KH_PXTable::TranslateField(char* buf)
  69.     {
  70.     char fieldType[10];
  71.     short sh;
  72.     long date;
  73.     double n;
  74.     int m, d, y, l;
  75.     PXFldType(tblHandle, fldHandle, 255, fieldType);
  76.     int isBlank;
  77.     pxErr = PXFldBlank(recHandle, fldHandle, &isBlank);
  78.  
  79.     switch(fieldType[0])
  80.     {
  81.     case 'A':
  82.         PXGetAlpha(recHandle, fldHandle, 255, buf);
  83.         return KH_STRING;
  84.     case 'D':         // Read in format DD.MM.YY
  85.         if(isBlank)
  86.         buf[0] = '\0';
  87.         else
  88.         {
  89.         char tmp[10];
  90.         strset(buf, '0');
  91.         PXGetDate(recHandle, fldHandle, &date);
  92.         PXDateDecode(date, &m, &d, &y);
  93.         itoa(d, tmp, 10);
  94.         strcpy(buf + 2 - strlen(tmp), tmp);
  95.         buf[2] = '.';
  96.         itoa(m, tmp, 10);
  97.         strcpy(buf + 5 - strlen(tmp), tmp);
  98.         buf[5] = '.';
  99.         itoa(y, tmp, 10);
  100.         strcpy(buf + 6, tmp);
  101.         }
  102.         return KH_DATE;
  103.     case 'S':
  104.         if(isBlank)
  105.         buf[0] = '\0';
  106.         else
  107.         {
  108.         PXGetShort(recHandle, fldHandle, &sh);
  109.         sprintf(buf, "%d", sh);
  110.         }
  111.         return KH_SHORT;
  112.     case 'N':
  113.         if(isBlank)
  114.         buf[0] = '\0';
  115.         else
  116.         {
  117.         PXGetDoub(recHandle, fldHandle, &n);
  118.         sprintf(buf, "%f", n);
  119.         }
  120.         return KH_NUMBER;
  121.     default:
  122.         buf[0] = '\0';
  123.         return KH_BLOB;
  124.     }
  125.     }
  126. //////////////////////////////////
  127. int KH_PXTable::testQuerry(char** shablon)
  128.     {
  129.     char s[255];
  130.     double d;
  131.     long l;
  132.     short sh;
  133.     int result = 1;
  134.     char fldType[6];
  135.     for(int i = 1; i <= nFlds; i++)
  136.     {
  137.     if(!shablon[i - 1][0])
  138.         continue;
  139.     PXFldType(tblHandle, i, 6, fldType);
  140.     switch(fldType[0])
  141.         {
  142.         case 'A':
  143.         PXGetAlpha(recHandle, i, 255, s);
  144.         result = Compare(shablon[i - 1], s);
  145.         break;
  146.         case 'N':
  147.         case '$':
  148.         PXGetDoub(recHandle, i, &d);
  149.         result = Compare(shablon[i - 1], d);
  150.         break;
  151.         case 'S':
  152.         PXGetShort(recHandle, i, &sh);
  153.         result = Compare(shablon[i - 1], sh);
  154.         break;
  155.         case 'D':
  156.         PXGetDate(recHandle, i, &l);
  157.         result = Compare(shablon[i - 1], d);
  158.         break;
  159.         default:
  160.         result = 1;           // No verification on BLOBs
  161.         break;
  162.         }
  163.     if(!result)
  164.         break;
  165.     }
  166.     return result;
  167.     }
  168. /////////////////////////////////
  169. int KH_PXTable::Find(char** shablon)
  170.     {
  171.     int eot = 0;
  172.     int first = 1;
  173.     while(1)
  174.     {
  175.     pxErr = PXRecGet(tblHandle, recHandle);
  176.     if((pxErr = PXRecNext(tblHandle)) != PXSUCCESS)
  177.         {
  178.         eot = 1;
  179.         if(first)
  180.         return 0;
  181.         first = 0;
  182.         }
  183.  
  184.     int result = testQuerry(shablon);
  185.  
  186.     if(result && !eot)
  187.         return 1;
  188.     if(result && eot)
  189.         return 2;
  190.     if(eot)
  191.         return 0;
  192.     }
  193.     }
  194. /////////////////////////////////
  195. int KH_PXTable::Compare(char* shab, char* field)
  196.     {
  197.     if(!shab[0])
  198.     return 1;
  199.     return !strcmp(shab, field);
  200.     }
  201. /////////////////////////////////
  202. int KH_PXTable::Compare(char* shab, double field)
  203.     {
  204.     if(!shab[0])
  205.     return 1;
  206.     return strtod(shab, NULL) == field;
  207.     }
  208. /////////////////////////////////
  209. int KH_PXTable::Compare(char* shab, long field)
  210.     {
  211.     if(!shab[0])
  212.     return 1;
  213.     return strtol(shab, NULL, 10) == field;
  214.     }
  215. /////////////////////////////////////
  216. int KH_PXTable::Compare(char* shab, short field)
  217.     {
  218.     if(!shab[0])
  219.     return 1;
  220.     return atoi(shab) == field;
  221.     }
  222. /////////////////////////////////////
  223. int KH_PXTable::putField(KH_PXFLD* f)
  224.     {
  225.     switch(f->type)
  226.     {
  227.     case KH_NUMBER:
  228.     case KH_MONEY:
  229.         if((pxErr = PXPutDoub(recHandle, fldHandle, f->n))
  230.         != PXSUCCESS)
  231.         return 0;
  232.         break;
  233.     case KH_STRING:
  234.         if((pxErr = PXPutAlpha(recHandle, fldHandle, f->str))
  235.         != PXSUCCESS)
  236.         return 0;
  237.         break;
  238.     case KH_DATE:
  239.         if((pxErr = PXPutDate(recHandle, fldHandle, f->date))
  240.         != PXSUCCESS)
  241.         return 0;
  242.         break;
  243.     case KH_SHORT:
  244.         if((pxErr = PXPutShort(recHandle, fldHandle, f->sh))
  245.         != PXSUCCESS)
  246.         return 0;
  247.         break;
  248.     default:         // BLOB put operations are supplied in ASK MANAGER
  249.         break;
  250.     }
  251.     return 1;
  252.     }
  253. /////////////////////////////////////
  254. int KH_PXTable::getField(KH_PXFLD* ret)
  255.     {
  256.     char buf[10];
  257.     PXFldType(tblHandle, fldHandle, 10, buf);
  258.     switch(buf[0])
  259.     {
  260.     case 'N':
  261.     case '$':
  262.         double d;
  263.         if((pxErr = PXGetDoub(recHandle, fldHandle,    &d))
  264.         != PXSUCCESS)
  265.         return 0;
  266.         ret->type = KH_NUMBER;
  267.         ret->n = d;
  268.         break;
  269.     case 'A':
  270.         if((pxErr = PXGetAlpha(recHandle, fldHandle, 255, ret->str))
  271.         != PXSUCCESS)
  272.         return 0;
  273.         ret->type = KH_STRING;
  274.         break;
  275.     case 'D':
  276.         long l;
  277.         if((pxErr = PXGetDate(recHandle, fldHandle, &l))
  278.         != PXSUCCESS)
  279.         return 0;
  280.         ret->type = KH_DATE;
  281.         ret->date = l;
  282.         break;
  283.     case 'S':
  284.         short sh;
  285.         if((pxErr = PXGetShort(recHandle, fldHandle, &sh))
  286.         != PXSUCCESS)
  287.         return 0;
  288.         ret->type = KH_SHORT;
  289.         ret->sh = sh;
  290.         break;
  291.     default:
  292.         if(strlen(buf) > 2)           // Not "M", but Mnnn (leader).
  293.         {
  294.         int blbSize;
  295.         pxErr = PXBlobQuickGet(recHandle, fldHandle, 255,
  296.             (char*)ret->str, &blbSize);
  297.         ret->sh = blbSize;
  298.         }
  299.         else
  300.         ret->str[0] = '\0';
  301.         ret->type = KH_BLOB;
  302.         break;
  303.     }
  304.     return 1;
  305.     }
  306. /////////////////////////////////////
  307. /*
  308. #include <iostream.h>
  309. #include <dos.h>
  310.  
  311. /////////////////////
  312. void main()
  313.     {
  314.     if(PXInit() != PXSUCCESS)
  315.     return;
  316.  
  317.     KH_PXTable table("demo.db");
  318.  
  319.     char* shablon[] = { "", "", "", "", "", "", "", "", "", "", "" };
  320.     char buf[255];
  321.     int eot;
  322.     while(table.Find(shablon) == 1)
  323.     {
  324.     for(int i = 1; i < 2; i++)
  325.         {
  326.         table.setFld(i);
  327.         table.TranslateField(buf);
  328.         cout << buf;
  329.         }
  330.     cout << "\n";
  331.     }
  332.     PXExit();
  333.     }
  334. */